package com.qst.service.impl;

import com.qst.pojo.dto.LoginDTO;
import com.qst.pojo.vo.LoginResponseVO;
import com.qst.pojo.dto.RegisterDTO;
import com.qst.pojo.entity.SystemSettings;
import com.qst.pojo.entity.User;
import com.qst.repository.SystemSettingsRepository;
import com.qst.repository.UserRepository;
import com.qst.service.AuthService;
import com.qst.service.NotificationService;
import com.qst.util.EmailValidator;
import com.qst.util.JwtUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;

/**
 * 认证服务实现类
 */
@Service
public class AuthServiceImpl implements AuthService {

    private static final Logger logger = LoggerFactory.getLogger(AuthServiceImpl.class);

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private SystemSettingsRepository settingsRepository;

    @Autowired
    private NotificationService notificationService;

    @Override
    public LoginResponseVO login(LoginDTO loginDTO) {
        // 查询用户
        User user = userRepository.findByUsername(loginDTO.getUsername())
                .orElseThrow(() -> new RuntimeException("用户名或密码错误"));

        // 验证密码（明文比较）
        if (!loginDTO.getPassword().equals(user.getPassword())) {
            logger.warn("用户 {} 密码错误", loginDTO.getUsername());
            throw new RuntimeException("用户名或密码错误");
        }

        // 检查用户状态
        if (user.getStatus() == User.UserStatus.inactive) {
            logger.warn("用户 {} 已被禁用", loginDTO.getUsername());
            throw new RuntimeException("该账号已被禁用");
        }

        // 检查系统维护模式
        if (isMaintenanceMode() && user.getRole() != User.UserRole.admin) {
            logger.warn("系统维护中，非管理员用户 {} 无法登录", loginDTO.getUsername());
            throw new RuntimeException("系统正在维护中，暂时无法登录");
        }

        // 生成Token
        String token = jwtUtil.generateToken(user.getUsername(), user.getId(), user.getRole().name());

        // 构建用户信息
        LoginResponseVO.UserVO userVO = new LoginResponseVO.UserVO(
                user.getId(),
                user.getUsername(),
                user.getRealName(),
                user.getRole().name(),
                user.getEmail(),
                user.getPhone()
        );

        // 构建返回数据（匹配前端期望格式）
        return new LoginResponseVO(token, userVO);
    }

    @Override
    public LoginResponseVO register(RegisterDTO registerDTO) {
        // 检查是否允许注册
        if (!isRegistrationAllowed()) {
            logger.warn("系统已关闭用户注册功能");
            throw new RuntimeException("系统暂时不允许新用户注册");
        }

        // 检查用户名是否已存在
        if (userRepository.findByUsername(registerDTO.getUsername()).isPresent()) {
            logger.warn("用户名 {} 已存在", registerDTO.getUsername());
            throw new RuntimeException("用户名已存在");
        }

        // 检查手机号是否已存在
        if (userRepository.findByPhone(registerDTO.getPhone()).isPresent()) {
            logger.warn("手机号 {} 已被注册", registerDTO.getPhone());
            throw new RuntimeException("手机号已被注册");
        }

        // 验证邮箱格式和域名
        if (!EmailValidator.validate(registerDTO.getEmail())) {
            String domain = EmailValidator.getDomain(registerDTO.getEmail());
            logger.warn("邮箱域名不支持: {}", domain);
            throw new RuntimeException("请使用常见邮箱服务商（如QQ、163、Gmail等）");
        }

        // 验证角色（只允许注册为客户或站点管理员，不允许注册为admin）
        User.UserRole userRole;
        try {
            userRole = User.UserRole.valueOf(registerDTO.getRole());
            if (userRole == User.UserRole.admin) {
                logger.warn("尝试注册为管理员角色");
                throw new RuntimeException("不允许注册为管理员");
            }
        } catch (IllegalArgumentException e) {
            logger.warn("无效的角色: {}", registerDTO.getRole());
            throw new RuntimeException("无效的用户角色");
        }

        // 创建新用户
        User user = new User();
        user.setUsername(registerDTO.getUsername());
        user.setPassword(registerDTO.getPassword()); // 明文密码
        user.setRealName(registerDTO.getRealName());
        user.setPhone(registerDTO.getPhone());
        user.setEmail(registerDTO.getEmail());
        user.setAddress(registerDTO.getAddress());
        user.setRole(userRole); // 根据用户选择设置角色
        user.setStatus(User.UserStatus.active); // 默认激活状态

        // 保存用户
        user = userRepository.save(user);

        // 发送注册成功通知邮件
        notificationService.sendUserRegistrationNotification(user);

        // 生成Token
        String token = jwtUtil.generateToken(user.getUsername(), user.getId(), user.getRole().name());

        // 构建用户信息
        LoginResponseVO.UserVO userVO = new LoginResponseVO.UserVO(
                user.getId(),
                user.getUsername(),
                user.getRealName(),
                user.getRole().name(),
                user.getEmail(),
                user.getPhone()
        );

        // 构建返回数据
        return new LoginResponseVO(token, userVO);
    }

    /**
     * 检查系统是否处于维护模式
     */
    private boolean isMaintenanceMode() {
        Optional<SystemSettings> setting = settingsRepository.findBySettingKey("system.maintenanceMode");
        return setting.map(s -> Boolean.parseBoolean(s.getSettingValue())).orElse(false);
    }

    /**
     * 检查是否允许用户注册
     */
    private boolean isRegistrationAllowed() {
        Optional<SystemSettings> setting = settingsRepository.findBySettingKey("system.allowRegistration");
        return setting.map(s -> Boolean.parseBoolean(s.getSettingValue())).orElse(true);
    }
}

